home *** CD-ROM | disk | FTP | other *** search
/ Champak 141 / (Vol 141) Oct 17 2011.iso / Games / despereaux-swings.swf / scripts / Box2D / Collision / b2PairManager.as < prev    next >
Encoding:
Text File  |  2011-10-17  |  9.2 KB  |  305 lines
  1. package Box2D.Collision
  2. {
  3.    import Box2D.Common.*;
  4.    import Box2D.Common.Math.*;
  5.    
  6.    public class b2PairManager
  7.    {
  8.        
  9.       
  10.       public var m_pairCount:int;
  11.       
  12.       public var m_pairBuffer:Array;
  13.       
  14.       public var m_callback:b2PairCallback;
  15.       
  16.       public var m_pairs:Array;
  17.       
  18.       public var m_pairBufferCount:int;
  19.       
  20.       public var m_hashTable:Array;
  21.       
  22.       public var m_broadPhase:b2BroadPhase;
  23.       
  24.       public var m_freePair:uint;
  25.       
  26.       public function b2PairManager()
  27.       {
  28.          var _loc1_:uint = 0;
  29.          super();
  30.          m_hashTable = new Array(b2Pair.b2_tableCapacity);
  31.          _loc1_ = 0;
  32.          while(_loc1_ < b2Pair.b2_tableCapacity)
  33.          {
  34.             m_hashTable[_loc1_] = b2Pair.b2_nullPair;
  35.             _loc1_++;
  36.          }
  37.          m_pairs = new Array(b2Settings.b2_maxPairs);
  38.          _loc1_ = 0;
  39.          while(_loc1_ < b2Settings.b2_maxPairs)
  40.          {
  41.             m_pairs[_loc1_] = new b2Pair();
  42.             _loc1_++;
  43.          }
  44.          m_pairBuffer = new Array(b2Settings.b2_maxPairs);
  45.          _loc1_ = 0;
  46.          while(_loc1_ < b2Settings.b2_maxPairs)
  47.          {
  48.             m_pairBuffer[_loc1_] = new b2BufferedPair();
  49.             _loc1_++;
  50.          }
  51.          _loc1_ = 0;
  52.          while(_loc1_ < b2Settings.b2_maxPairs)
  53.          {
  54.             m_pairs[_loc1_].proxyId1 = b2Pair.b2_nullProxy;
  55.             m_pairs[_loc1_].proxyId2 = b2Pair.b2_nullProxy;
  56.             m_pairs[_loc1_].userData = null;
  57.             m_pairs[_loc1_].status = 0;
  58.             m_pairs[_loc1_].next = _loc1_ + 1;
  59.             _loc1_++;
  60.          }
  61.          m_pairs[int(b2Settings.b2_maxPairs - 1)].next = b2Pair.b2_nullPair;
  62.          m_pairCount = 0;
  63.          m_pairBufferCount = 0;
  64.       }
  65.       
  66.       public static function EqualsPair(param1:b2BufferedPair, param2:b2BufferedPair) : Boolean
  67.       {
  68.          return param1.proxyId1 == param2.proxyId1 && param1.proxyId2 == param2.proxyId2;
  69.       }
  70.       
  71.       public static function Hash(param1:uint, param2:uint) : uint
  72.       {
  73.          var _loc3_:uint = 0;
  74.          _loc3_ = uint(param2 << 16 & 4294901760 | param1);
  75.          _loc3_ = uint(~_loc3_ + (_loc3_ << 15 & 4294934528));
  76.          _loc3_ ^= _loc3_ >> 12 & 1048575;
  77.          _loc3_ += _loc3_ << 2 & 4294967292;
  78.          _loc3_ ^= _loc3_ >> 4 & 268435455;
  79.          _loc3_ *= 2057;
  80.          return uint(_loc3_ ^ _loc3_ >> 16 & 65535);
  81.       }
  82.       
  83.       public static function Equals(param1:b2Pair, param2:uint, param3:uint) : Boolean
  84.       {
  85.          return param1.proxyId1 == param2 && param1.proxyId2 == param3;
  86.       }
  87.       
  88.       private function FindHash(param1:uint, param2:uint, param3:uint) : b2Pair
  89.       {
  90.          var _loc4_:b2Pair = null;
  91.          var _loc5_:uint = 0;
  92.          _loc5_ = uint(m_hashTable[param3]);
  93.          _loc4_ = m_pairs[_loc5_];
  94.          while(_loc5_ != b2Pair.b2_nullPair && Equals(_loc4_,param1,param2) == false)
  95.          {
  96.             _loc5_ = _loc4_.next;
  97.             _loc4_ = m_pairs[_loc5_];
  98.          }
  99.          if(_loc5_ == b2Pair.b2_nullPair)
  100.          {
  101.             return null;
  102.          }
  103.          return _loc4_;
  104.       }
  105.       
  106.       private function Find(param1:uint, param2:uint) : b2Pair
  107.       {
  108.          var _loc3_:uint = 0;
  109.          var _loc4_:uint = 0;
  110.          if(param1 > param2)
  111.          {
  112.             _loc4_ = param1;
  113.             param1 = param2;
  114.             param2 = _loc4_;
  115.          }
  116.          _loc3_ = uint(Hash(param1,param2) & b2Pair.b2_tableMask);
  117.          return FindHash(param1,param2,_loc3_);
  118.       }
  119.       
  120.       private function ValidateBuffer() : void
  121.       {
  122.       }
  123.       
  124.       public function Commit() : void
  125.       {
  126.          var _loc1_:b2BufferedPair = null;
  127.          var _loc2_:int = 0;
  128.          var _loc3_:int = 0;
  129.          var _loc4_:Array = null;
  130.          var _loc5_:b2Pair = null;
  131.          var _loc6_:b2Proxy = null;
  132.          var _loc7_:b2Proxy = null;
  133.          _loc3_ = 0;
  134.          _loc4_ = m_broadPhase.m_proxyPool;
  135.          _loc2_ = 0;
  136.          while(_loc2_ < m_pairBufferCount)
  137.          {
  138.             _loc1_ = m_pairBuffer[_loc2_];
  139.             (_loc5_ = Find(_loc1_.proxyId1,_loc1_.proxyId2)).ClearBuffered();
  140.             _loc6_ = _loc4_[_loc5_.proxyId1];
  141.             _loc7_ = _loc4_[_loc5_.proxyId2];
  142.             if(_loc5_.IsRemoved())
  143.             {
  144.                if(_loc5_.IsFinal() == true)
  145.                {
  146.                   m_callback.PairRemoved(_loc6_.userData,_loc7_.userData,_loc5_.userData);
  147.                }
  148.                _loc1_ = m_pairBuffer[_loc3_];
  149.                _loc1_.proxyId1 = _loc5_.proxyId1;
  150.                _loc1_.proxyId2 = _loc5_.proxyId2;
  151.                _loc3_++;
  152.             }
  153.             else if(_loc5_.IsFinal() == false)
  154.             {
  155.                _loc5_.userData = m_callback.PairAdded(_loc6_.userData,_loc7_.userData);
  156.                _loc5_.SetFinal();
  157.             }
  158.             _loc2_++;
  159.          }
  160.          _loc2_ = 0;
  161.          while(_loc2_ < _loc3_)
  162.          {
  163.             _loc1_ = m_pairBuffer[_loc2_];
  164.             RemovePair(_loc1_.proxyId1,_loc1_.proxyId2);
  165.             _loc2_++;
  166.          }
  167.          m_pairBufferCount = 0;
  168.          if(b2BroadPhase.s_validate)
  169.          {
  170.             ValidateTable();
  171.          }
  172.       }
  173.       
  174.       public function RemoveBufferedPair(param1:int, param2:int) : void
  175.       {
  176.          var _loc3_:b2BufferedPair = null;
  177.          var _loc4_:b2Pair = null;
  178.          if((_loc4_ = Find(param1,param2)) == null)
  179.          {
  180.             return;
  181.          }
  182.          if(_loc4_.IsBuffered() == false)
  183.          {
  184.             _loc4_.SetBuffered();
  185.             _loc3_ = m_pairBuffer[m_pairBufferCount];
  186.             _loc3_.proxyId1 = _loc4_.proxyId1;
  187.             _loc3_.proxyId2 = _loc4_.proxyId2;
  188.             ++m_pairBufferCount;
  189.          }
  190.          _loc4_.SetRemoved();
  191.          if(b2BroadPhase.s_validate)
  192.          {
  193.             ValidateBuffer();
  194.          }
  195.       }
  196.       
  197.       private function RemovePair(param1:uint, param2:uint) : *
  198.       {
  199.          var _loc3_:b2Pair = null;
  200.          var _loc4_:uint = 0;
  201.          var _loc5_:uint = 0;
  202.          var _loc6_:b2Pair = null;
  203.          var _loc7_:uint = 0;
  204.          var _loc8_:uint = 0;
  205.          var _loc9_:* = undefined;
  206.          if(param1 > param2)
  207.          {
  208.             _loc7_ = param1;
  209.             param1 = param2;
  210.             param2 = _loc7_;
  211.          }
  212.          _loc4_ = uint(Hash(param1,param2) & b2Pair.b2_tableMask);
  213.          _loc5_ = uint(m_hashTable[_loc4_]);
  214.          _loc6_ = null;
  215.          while(_loc5_ != b2Pair.b2_nullPair)
  216.          {
  217.             if(Equals(m_pairs[_loc5_],param1,param2))
  218.             {
  219.                _loc8_ = _loc5_;
  220.                _loc3_ = m_pairs[_loc5_];
  221.                if(_loc6_)
  222.                {
  223.                   _loc6_.next = _loc3_.next;
  224.                }
  225.                else
  226.                {
  227.                   m_hashTable[_loc4_] = _loc3_.next;
  228.                }
  229.                _loc3_ = m_pairs[_loc8_];
  230.                _loc9_ = _loc3_.userData;
  231.                _loc3_.next = m_freePair;
  232.                _loc3_.proxyId1 = b2Pair.b2_nullProxy;
  233.                _loc3_.proxyId2 = b2Pair.b2_nullProxy;
  234.                _loc3_.userData = null;
  235.                _loc3_.status = 0;
  236.                m_freePair = _loc8_;
  237.                --m_pairCount;
  238.                return _loc9_;
  239.             }
  240.             _loc5_ = (_loc6_ = m_pairs[_loc5_]).next;
  241.          }
  242.          return null;
  243.       }
  244.       
  245.       public function Initialize(param1:b2BroadPhase, param2:b2PairCallback) : void
  246.       {
  247.          m_broadPhase = param1;
  248.          m_callback = param2;
  249.       }
  250.       
  251.       public function AddBufferedPair(param1:int, param2:int) : void
  252.       {
  253.          var _loc3_:b2BufferedPair = null;
  254.          var _loc4_:b2Pair = null;
  255.          if((_loc4_ = AddPair(param1,param2)).IsBuffered() == false)
  256.          {
  257.             _loc4_.SetBuffered();
  258.             _loc3_ = m_pairBuffer[m_pairBufferCount];
  259.             _loc3_.proxyId1 = _loc4_.proxyId1;
  260.             _loc3_.proxyId2 = _loc4_.proxyId2;
  261.             ++m_pairBufferCount;
  262.          }
  263.          _loc4_.ClearRemoved();
  264.          if(b2BroadPhase.s_validate)
  265.          {
  266.             ValidateBuffer();
  267.          }
  268.       }
  269.       
  270.       private function AddPair(param1:uint, param2:uint) : b2Pair
  271.       {
  272.          var _loc3_:uint = 0;
  273.          var _loc4_:b2Pair = null;
  274.          var _loc5_:uint = 0;
  275.          var _loc6_:uint = 0;
  276.          if(param1 > param2)
  277.          {
  278.             _loc6_ = param1;
  279.             param1 = param2;
  280.             param2 = _loc6_;
  281.          }
  282.          _loc3_ = uint(Hash(param1,param2) & b2Pair.b2_tableMask);
  283.          if((_loc4_ = _loc4_ = FindHash(param1,param2,_loc3_)) != null)
  284.          {
  285.             return _loc4_;
  286.          }
  287.          _loc5_ = m_freePair;
  288.          _loc4_ = m_pairs[_loc5_];
  289.          m_freePair = _loc4_.next;
  290.          _loc4_.proxyId1 = param1;
  291.          _loc4_.proxyId2 = param2;
  292.          _loc4_.status = 0;
  293.          _loc4_.userData = null;
  294.          _loc4_.next = m_hashTable[_loc3_];
  295.          m_hashTable[_loc3_] = _loc5_;
  296.          ++m_pairCount;
  297.          return _loc4_;
  298.       }
  299.       
  300.       private function ValidateTable() : void
  301.       {
  302.       }
  303.    }
  304. }
  305.